from PyQt6.QtCore import QFile
from PyQt6.QtWidgets import QDialog, QMessageBox, QAbstractItemView
from PyQt6.uic import loadUi
import json
import os
import configparser
from PyQt6.QtGui import QStandardItemModel, QStandardItem

from MyMessageBox import MyMessageBox
from UI.ConfigDialog import Ui_ConfigDialogClass
import Global


class ConfigDialog(QDialog,Ui_ConfigDialogClass):
    def __init__(self, parent=None, m_currentRow=-1):
        super().__init__(parent)
        self.setupUi(self)
        #loadUi("UI/ConfigDialog.ui", self)
        self.m_currentRow = m_currentRow
        # 在这里可以使用self.row_number进行进一步的操作
        self.setWindowTitle(f"配置[{self.m_currentRow+1}]")
        self.load_config_list()

        # 连接按钮事件
        self.btn_ReadConfig.clicked.connect(self.read_config)
        self.btn_DelConfig.clicked.connect(self.delete_config)
        self.btn_SaveConfig.clicked.connect(self.save_config)
        self.btn_AddTask.clicked.connect(self.add_task)
        self.btn_DelTask.clicked.connect(self.del_task) 
        # 连接双击事件
        self.tableView_Task.doubleClicked.connect(self.add_task)
        self.tableView_RunTask.doubleClicked.connect(self.del_task)
        self.btn_AddUseItem.clicked.connect(self.add_use_item)
        self.btn_AddAutoUseItem.clicked.connect(self.add_auto_use_item)
        self.btn_AddAutoSellItem.clicked.connect(self.add_auto_sell_item)

        #采集配置页面'
        self.pushButton_GetPosition.clicked.connect(self.GetPosition_Click)
        self.pushButton_AddCurPosition.clicked.connect(self.AddCurPosition_Click)
        self.btn_SysConfig.clicked.connect(self.SysConfig_Click)
        self.pushButton_SynConfigToCurWind.clicked.connect(self.SynConfigToCurWind_Click)

        self.horizontalSlider.valueChanged.connect(self.on_slider_value_changed)
        self.doubleSpinBox_Speed.valueChanged.connect(self.on_doubleSpinBox_Speed_value_changed)

        self.Init_AllTables()
        self.Init_Datas()
        # 读取 Task.json 文件并显示在 tableView_Task 中
        self.load_tasks()
        self.read_config()
    def Init_Datas(self):
        # 初始化角色数量下拉框
        for i in range(1, 5):
            self.cb_roleIndex.addItem(str(i), i)

        self.inicf = configparser.ConfigParser()
        self.inicf.read(Global.ConfigFileName, encoding='utf-8')
        country= self.inicf.get("System", "国家",fallback='kr')
        # 读取配置文件，指定编码为utf-8
        with open('data/Job.json', 'r', encoding='utf-8') as file:
            try:
                role_config = json.load(file)
            except json.JSONDecodeError:
                role_config = {}  # 如果不是合法的 JSON，初始化为空字典

        jobs = role_config.get(country, [])
         # 遍历职业列表，只添加enable为true的职业
        for job in jobs:
            if job.get('enable', False):  # 如果enable为True
                # 将职业名称显示在下拉框中，将职业ID设置为该项的data
                self.cb_job.addItem(job['name'], job['id'])
                self.cb_job_2.addItem(job['name'], job['id'])
                self.cb_job_3.addItem(job['name'], job['id'])
                self.cb_job_4.addItem(job['name'], job['id'])

        self.cb_job.setCurrentIndex(-1)
        self.cb_job_2.setCurrentIndex(-1)
        self.cb_job_3.setCurrentIndex(-1)
        self.cb_job_4.setCurrentIndex(-1)

    def Init_AllTables(self):
        # 任务窗口
        self.tableView_Task.setModel(QStandardItemModel())
        self.tableView_RunTask.setModel(QStandardItemModel())
        model_task = self.tableView_Task.model()
        model_task.setHorizontalHeaderLabels(["任务名称(支持双击和多选)"])  # 修改这里
        self.tableView_Task.horizontalHeader().setStretchLastSection(True)  # 修改这里
        self.tableView_Task.verticalHeader().setVisible(False)
        self.tableView_Task.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.tableView_Task.setShowGrid(True)

        model_Runtask = self.tableView_RunTask.model()
        model_Runtask.setHorizontalHeaderLabels(["当前任务(支持双击和多选)"])  # 修改这里
        self.tableView_RunTask.horizontalHeader().setStretchLastSection(True)  # 修改这里
        self.tableView_RunTask.verticalHeader().setVisible(False)
        self.tableView_RunTask.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
        self.tableView_RunTask.setShowGrid(True)

    def load_config_list(self):
        """加载config文件夹下的配置文件列表"""
        config_dir = "config"
        if not os.path.exists(config_dir):
            os.makedirs(config_dir)

        self.cb_ConfigName.clear()
        for filename in os.listdir(config_dir):
            if filename.endswith(".cfg"):
                self.cb_ConfigName.addItem(filename[:-4])
        self.cb_ConfigName.setCurrentIndex(-1)  # 默认设置cb_ConfigName索引为-1
        if self.m_currentRow > -1:
            configFileName = Global.G_Game[self.m_currentRow].data["config"]
            if configFileName.endswith(".cfg"):  # 修改这里
                configFileName = configFileName[:-4]  # 修改这里
            if configFileName:
                index = self.cb_ConfigName.findText(configFileName)
                if index != -1:
                    self.cb_ConfigName.setCurrentIndex(index)
                    return

    def read_config(self):
        """读取选中的配置文件"""
        if self.m_currentRow < 0:
            return

        config_name = self.cb_ConfigName.currentText()
        if not config_name:
            return

        try:
            with open(f"config/{config_name}.cfg", "r", encoding="utf-8") as f:
                self.from_json(f.read())
        except Exception as e:
            QMessageBox.warning(self, "错误", f"读取配置文件失败: {e}")

    def delete_config(self):
        """删除选中的配置文件"""
        config_name = self.cb_ConfigName.currentText()
        if not config_name:
            return

        # 弹出确认对话框
        reply = QMessageBox.question(
            self,
            "确认删除",
            f"确定要删除配置文件 {config_name}.cfg 吗？",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
            QMessageBox.StandardButton.No
        )

        # 用户点击Yes才执行删除操作
        if reply == QMessageBox.StandardButton.Yes:
            try:
                os.remove(f"config/{config_name}.cfg")
                self.load_config_list()  # 刷新列表
                QMessageBox.information(self, "成功", "配置文件删除成功")
            except Exception as e:
                QMessageBox.warning(self, "错误", f"删除配置文件失败: {e}")

    def save_config(self):
        """保存当前配置"""
        config_name = self.cb_ConfigName.currentText()
        if not config_name:
            QMessageBox.warning(self, "警告", "请先填写配置文件名")
            return

        try:
            with open(f"config/{config_name}.cfg", "w", encoding="utf-8") as f:
                f.write(self.to_json())
            QMessageBox.information(self, "成功", f"配置文件 [{config_name}] 保存成功")
            self.load_config_list()  # 刷新列表
            # 选中当前配置并读取
            index = self.cb_ConfigName.findText(config_name)
            if index != -1:
                self.cb_ConfigName.setCurrentIndex(index)
                self.read_config()  # 重新读取配置
        except Exception as e:
            Global.LOGE(f"保存配置文件失败: {e}")

    def to_json(self):
        """将控件数据序列化为JSON"""
        data={}
        jobs = [
        self.cb_job.currentData() or 0,
        self.cb_job_2.currentData() or 0,
        self.cb_job_3.currentData() or 0,
        self.cb_job_4.currentData() or 0
        ]
        data["职业"] = jobs
        # 保存当前运行任务列表
        tasks = []
        model = self.tableView_RunTask.model()
        for row in range(model.rowCount()):
            task_name = model.item(row, 0).text()
            tasks.append(task_name)
        data["任务列表"] = tasks
        data["道具使用列表"]=self.edit_UseItems.toPlainText()
        data["自动道具列表"] = self.edit_AutoUseItems.toPlainText()
        data["自动出售列表"] = self.edit_AutoSellItems.toPlainText()
        #采集配置
        data["采集配置"]={}
        data["采集配置"]["Collect_Cao"] = self.checkBox_Cao.isChecked()
        data["采集配置"]["Collect_Tie"] = self.checkBox_Tie.isChecked()
        data["采集配置"]["Collect_Stone"] = self.checkBox_Stone.isChecked()
        data["采集配置"]["Collect_HuPo"] = self.checkBox_HuPo.isChecked()
        data["采集配置"]["Collect_Box"] = self.checkBox_Box.isChecked()
        data["采集配置"]["IsCompose"] = self.checkBox_Compose.isChecked()
        data["采集配置"]["IsComposeUnBind"] = self.checkBox_IsComposeUnBind.isChecked()
        data["采集配置"]["IsVerify"] = self.checkBox_two_factor_status.isChecked()
        data["采集配置"]["Points"]=self.plainTextEdit_Points.toPlainText()
        data["speed"]=self.doubleSpinBox_Speed.value()
        return json.dumps(data, indent=4, ensure_ascii=False)

    def from_json(self, json_str):
        """从JSON解析数据并赋值给控件"""
        self.Init_AllTables()
        self.load_tasks() #需要初始化任务列表的数据
        data = json.loads(json_str)
        # 恢复职业选择
        jobs = data.get("职业", [0, 0, 0, 0]) 
        # 设置每个职业下拉框的值
        job_combos = [self.cb_job, self.cb_job_2, self.cb_job_3, self.cb_job_4]
        for i, (combo, job_id) in enumerate(zip(job_combos, jobs)):
            # 查找对应的索引
            index = combo.findData(job_id)
            if index != -1:  # 如果找到匹配的职业ID
                combo.setCurrentIndex(index)
            else:
                combo.setCurrentIndex(-1)  # 如果没找到，设置为未选择状态
        # 恢复任务列表
        saved_tasks = data.get("任务列表", [])
        model_task = self.tableView_Task.model()
        model_run_task = self.tableView_RunTask.model()

        # 清空当前运行任务列表
        model_run_task.removeRows(0, model_run_task.rowCount())

        # 遍历所有已保存的任务
        for task_name in saved_tasks:
            # 在任务列表中查找对应的任务
            found = False
            for row in range(model_task.rowCount()):
                if model_task.item(row, 0).text() == task_name:
                    # 找到任务后，添加到运行任务列表并从任务列表中移除
                    model_run_task.appendRow([QStandardItem(task_name)])
                    model_task.removeRow(row)
                    found = True
                    break
            if not found:
                # 如果在任务列表中没找到，直接添加到运行任务列表
                model_run_task.appendRow([QStandardItem(task_name)])

        self.edit_UseItems.setPlainText(data.get("道具使用列表", ''))
        self.edit_AutoUseItems.setPlainText(data.get("自动道具列表", ''))
        self.edit_AutoSellItems.setPlainText(data.get("自动出售列表", ''))

        # 采集配置
        collect_config = data.get("采集配置", {})
        self.checkBox_Cao.setChecked(collect_config.get("Collect_Cao", False))
        self.checkBox_Tie.setChecked(collect_config.get("Collect_Tie", False))
        self.checkBox_Stone.setChecked(collect_config.get("Collect_Stone", False))
        self.checkBox_HuPo.setChecked(collect_config.get("Collect_HuPo", False))
        self.checkBox_Box.setChecked(collect_config.get("Collect_Box", False))
        self.checkBox_Compose.setChecked(collect_config.get("IsCompose", False))
        self.checkBox_IsComposeUnBind.setChecked(collect_config.get("IsComposeUnBind", False))
        self.checkBox_two_factor_status.setChecked(collect_config.get("IsVerify", False))
        self.plainTextEdit_Points.setPlainText(collect_config.get("Points", ''))
        self.doubleSpinBox_Speed.setValue(data.get("speed", 1.0))

    def load_tasks(self):
        """读取 Task.json 文件并显示在 tableView_Task 中"""
        task_file = os.path.join("data", "Task.json")
        if os.path.exists(task_file):
            with open(task_file, "r", encoding="utf-8") as f:
                tasks = json.load(f)
                model = self.tableView_Task.model()
                for task in tasks:
                    model.appendRow([QStandardItem(task["name"])])

    def add_use_item(self):
        """添加道具到使用列表"""
        item_name = self.edit_useItemName.text().strip()
        if not item_name:
            return

        current_items = self.edit_UseItems.toPlainText().strip()
        if current_items:
            # 如果已经有内容，添加分隔符和新项目
            new_items = f"{current_items}>>{item_name}"
        else:
            # 如果是空的，直接添加新项目
            new_items = item_name

        self.edit_UseItems.setPlainText(new_items)
        self.edit_useItemName.clear()

    def add_auto_use_item(self):
        """添加道具到自动使用列表"""
        item_name = self.edit_useAutoItemName.text().strip()
        if not item_name:
            return

        current_items = self.edit_AutoUseItems.toPlainText().strip()
        if current_items:
            # 如果已经有内容，添加分隔符和新项目
            new_items = f"{current_items}>>{item_name}"
        else:
            # 如果是空的，直接添加新项目
            new_items = item_name

        self.edit_AutoUseItems.setPlainText(new_items)
        self.edit_useAutoItemName.clear()
    def add_auto_sell_item(self):
        """添加道具到自动使用列表"""
        item_name = self.edit_SellAutoItemName.text().strip()
        if not item_name:
            return

        current_items = self.edit_AutoSellItems.toPlainText().strip()
        if current_items:
            # 如果已经有内容，添加分隔符和新项目
            new_items = f"{current_items}>>{item_name}"
        else:
            # 如果是空的，直接添加新项目
            new_items = item_name

        self.edit_AutoSellItems.setPlainText(new_items)
        self.edit_SellAutoItemName.clear()
    def add_task(self):
        """将 tableView_Task 中的数据添加到 tableView_RunTask，并从 tableView_Task 中删除该任务"""
        selected_indexes = self.tableView_Task.selectedIndexes()
        if not selected_indexes:
            QMessageBox.warning(self, "警告", "请选择一个任务")
            return

        model_task = self.tableView_Task.model()
        model_run_task = self.tableView_RunTask.model()
        for index in sorted(selected_indexes, key=lambda x: x.row(), reverse=True):
            row = index.row()
            task_name = model_task.item(row, 0).text()
            model_run_task.appendRow([QStandardItem(task_name)])
            model_task.removeRow(row)

    def del_task(self):
        """将 tableView_RunTask 中的数据删除，并添加回 tableView_Task"""
        selected_indexes = self.tableView_RunTask.selectedIndexes()
        if not selected_indexes:
            QMessageBox.warning(self, "警告", "请选择一个任务")
            return

        model_task = self.tableView_Task.model()
        model_run_task = self.tableView_RunTask.model()
        for index in sorted(selected_indexes, key=lambda x: x.row(), reverse=True):
            row = index.row()
            task_name = model_run_task.item(row, 0).text()
            model_task.appendRow([QStandardItem(task_name)])
            model_run_task.removeRow(row)
    def ValidPos(self,position):
        import re
        pattern = r'^-?\d+\.\d+,-?\d+\.\d+,-?\d+\.\d+$'
        if not re.match(pattern, position):
            return False
        return True
    def AddCurPosition_Click(self):
        """处理添加当前位置按钮的点击事件"""
        # 获取输入的坐标文本
        position_text = self.lineEdit_CurPosition.text()
        if not self.ValidPos(position_text):
            MyMessageBox.show("错误", "坐标格式不正确")
            return
        # 将光标移动到末尾
        cursor = self.plainTextEdit_Points.textCursor()
        cursor.movePosition(cursor.MoveOperation.End)
        self.plainTextEdit_Points.setTextCursor(cursor)
        if len(self.plainTextEdit_Points.toPlainText()) > 0:
            self.plainTextEdit_Points.insertPlainText('|')
        self.plainTextEdit_Points.insertPlainText(position_text)
        self.lineEdit_CurPosition.setText('')
    def GetPosition_Click(self):
        data={}
        data["method"]="GetPosition"
        Global.G_Server.SendData(self.m_currentRow,data)
    def SysConfig_Click(self):
        config_name = self.cb_ConfigName.currentText()
        if len(config_name) == 0:
            MyMessageBox.show("错误", "请先填写配置名称,并保存后再操作")
            return
        config_name = config_name + ".cfg"
        cfFile = QFile(f"config/{config_name}")
        if cfFile.exists() == False:
            MyMessageBox.show("错误", f"配置文件{config_name}不存在,请先保存")
            return
        for i in range(len(Global.G_Game)):
            if Global.G_Game[i].data["config"] == config_name and Global.G_Game[i].socket!=None and Global.G_Game[i].data["processId"]>0:
                Global.LOGD(self.m_currentRow, f"同步配置到窗口{i}")
                Global.G_Server.SendConfig(i)

        QMessageBox.information(
            None,  # 父窗口（None 表示无父窗口）
            "提示",  # 标题
            "操作成功！"  # 内容
        )
    def SynConfigToCurWind_Click(self):
        config_name = self.cb_ConfigName.currentText()
        if len(config_name) == 0:
            MyMessageBox.show("错误", "请先填写配置名称,并保存后再操作")
            return
        config_name = config_name + ".cfg"
        cfFile = QFile(f"config/{config_name}")
        if cfFile.exists() == False:
            MyMessageBox.show("错误", f"配置文件{config_name}不存在,请先保存")
            return
        if self.m_currentRow>-1:
            Global.LOGD(f"同步配置到窗口{self.m_currentRow}")
            Global.G_Server.SendConfig(self.m_currentRow)
            QMessageBox.information(
                None,  # 父窗口（None 表示无父窗口）
                "提示",  # 标题
                "操作成功！"  # 内容
            )

    def on_slider_value_changed(self, value):
        self.doubleSpinBox_Speed.setValue(value)

    def on_doubleSpinBox_Speed_value_changed(self, value):
        self.horizontalSlider.setValue(int(value))
